class Singleton
{
private:
	Singleton();
	Singleton(coinst Singleton& singleton);
public:
	static Singleton* getInstance();
	static Singleton* m_instance;
}

Singleton* Singleton:: m_instance = nullptr;

//非线程安全版本
Singleton* Singleton::getInstance()
{
	if(m_instance == nullptr)
	{
		m_instance == new Singleton();
	}
	return m_instance;
}

//线程安全版本,但锁代价过高,读也会占用资源
Singleton* Singleton::getInstance()
{
	Lock lock;
	if(m_instance == nullptr)
	{
		m_instance == new Singleton();
	}
	return m_instance;
} 

//双检查锁,但由于内存读写reorder不安全,编译器优化问题先分配内存
Singleton* Singleton::getInstance()
{
	if(m_instance == nullptr)
	{
		Lock lock;
		if(m_instance == nullptr)
		{
			m_instance == new Singleton();
		}
	}
	return m_instance;
} 

//C++ 11
std:: atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance()
{
	Singleton* tmp = m_instance.load(std::memory_order_relaxed);
	std::atomic_thread_fence(std::memory_order_acquire);
	if(tmp == nullptr)
	{
		std::lock_guard<std::mutex> lock(m_mutex);
		tmp = m_instance.load(std::memory_order_relaxed);//获取内存fence
		if(tmp == nullptr)
		{
			tmp = new Singleton;
			std::atomic_thread_fence(std::memory_order_release);//释放内存fence
			m_instance.store(tmp,std::memory_order_relaxed);
		}
	}
	return tmp;
}